package 动态规划;

/**
 * ---------------------------------------------------------
 * <h></h>
 * <p>
 * 给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。
 *
 * 你可以对一个单词进行如下三种操作：
 *
 * 插入一个字符
 * 删除一个字符
 * 替换一个字符
 *  
 *
 * 示例 1：
 *
 * 输入：word1 = "horse", word2 = "ros"
 * 输出：3
 * 解释：
 * horse -> rorse (将 'h' 替换为 'r')
 * rorse -> rose (删除 'r')
 * rose -> ros (删除 'e')
 * 示例 2：
 *
 * 输入：word1 = "intention", word2 = "execution"
 * 输出：5
 * 解释：
 * intention -> inention (删除 't')
 * inention -> enention (将 'i' 替换为 'e')
 * enention -> exention (将 'n' 替换为 'x')
 * exention -> exection (将 'n' 替换为 'c')
 * exection -> execution (插入 'u')
 *  
 *
 * 提示：
 *
 * 0 <= word1.length, word2.length <= 500
 * word1 和 word2 由小写英文字母组成
 *
 * 链接：https://leetcode-cn.com/problems/edit-distance
 * </p>
 * Created by Frank on 2021/4/7.
 * <a href="mailto:frankyao10110@gmail.com">Contact me</a>
 * ---------------------------------------------------------
 */
public class _编辑距离 {
    public int minDistance(String word1, String word2) {
        //假设word1为字符数组s1，长度为n1, word2为字符数组s2，长度为n2,dp是长度为[n1 + 1] * [n2 + 1]的二维数组
        //dp[i][j]代表将s1[0,i]转换为s2[0,j]的操作次数,dp[n1][n2]就是要的答案
        //dp[0][j]代表将空字符s1转换为s2，只需要对s1执行n2次插入操作
        //dp[i][0]代表将s1转换为空字符s2，只需要对s1执行n1次删除操作
        //其他情况一共可以有4种情况，分别对应插入、删除和替换（最后一个字符是否相等）；
        //1、删除s1的最后一个字符，得到s1[0,i - 1),转化为s2[0,j)则dp[i][j] = 1 + dp[i - 1][j] （加上一次恢复删除的操作）；
        //2、将s1[0,i)转化为s2[0,j - 1)，再插入s2[j-1]，得到s2[0,j)，则dp[i][j] = dp[i][j-1] + 1 (加上一次插入s2最后一个字符的操作）；
        //3、如果s1[i-1] != s2[j-1]即最后一个字符不相等，将s1[0, i - 1)转化为s2[0, j - 1)，
        //   则dp[i][j] = dp[i - 1][j - 1] + 1（加上一次替换操作，将最后一个字符s2(i)替换为s2(j)）；
        //4、如果s1[i-1] == s2[j-1]即最后一个字符相等，则dp[i][j] = dp[i - 1][j - 1]；

        char[] s1 = word1.toCharArray();
        char[] s2 = word2.toCharArray();

        int len1 = s1.length + 1;
        int len2 = s2.length + 1;

        int[][] dp = new int[len1][len2];

        for (int i = 0; i < len1; i++) {
            dp[i][0] = i;
        }

        for (int j = 0; j < len2; j++) {
            dp[0][j] = j;
        }

        for (int i = 1; i < len1; i++) {
            for (int j = 1; j < len2; j++) {
                int minCount = Integer.MAX_VALUE;
                //1、删除操作的操作次数dp[i][j] = dp[i - 1][j] + 1;
                if (dp[i - 1][j] + 1 < minCount) {
                    minCount = dp[i - 1][j] + 1;
                }

                //2、插入操作dp[i][j-1] + 1
                if (dp[i][j - 1] + 1 < minCount) {
                    minCount = dp[i][j - 1] + 1;
                }

                if (s1[i - 1] != s2[j - 1]) {
                    if (dp[i - 1][j - 1] + 1 < minCount) {
                        minCount = dp[i - 1][j - 1] + 1;
                    }
                }else {
                    if (dp[i - 1][j - 1] < minCount) {
                        minCount = dp[i - 1][j - 1];
                    }
                }

                dp[i][j] = minCount;
            }
        }

        return dp[s1.length][s2.length];
    }
}
